WOLF core
WOLF: A Modular Estimation Framework for Robotics
XXXXXXXXXXXXXXXXXXXXXXXXvoid(0)" frameborder="0" name="MSearchResults" id="MSearchResults">
Functions
wolf::SE2 Namespace Reference

Functions

template<class T >
Matrix< T, 2, 2 > skew (const T &t)
 
template<class D >
Matrix< typename D::Scalar, 2, 1 > skewed (const MatrixBase< D > &t)
 Compute [1]_x * t = (-t.y ; t.x) More...
 
template<typename T >
Matrix< T, 2, 2 > V_helper (const T theta)
 V(theta) matrix, so that exp([rho, theta]) = [V(theta) * rho, theta]. See [1] eq. 158. More...
 
template<typename T >
Matrix< T, 2, 2 > V_inv_helper (const T theta)
 Inverse of V(theta), so that log([p, theta]) = [V(theta).inv * p, theta]. More...
 
template<class D , typename T >
Matrix< T, 2, 1 > J_Vp_theta (const MatrixBase< D > &p, const T theta)
 Jacobian of V(theta)*p wrt theta. More...
 
template<typename D >
Matrix< typename D::Scalar, 3, 3 > jac_SE2_left (const MatrixBase< D > &tangent)
 Left Jacobian of SE(2), with tangent = [rho, theta]. See [1] eq. 164. More...
 
template<typename D >
Matrix< typename D::Scalar, 3, 3 > jac_SE2_right (const MatrixBase< D > &tangent)
 Right Jacobian of SE(2), with tangent = [rho, theta]. See [1] eq. 163. More...
 
template<typename D >
Matrix< typename D::Scalar, 3, 3 > jac_SE2_left_inv (const MatrixBase< D > &tangent)
 Inverse of the left Jacobian of SE(2), with tangent = [rho, theta]. More...
 
template<typename D >
Matrix< typename D::Scalar, 3, 3 > jac_SE2_right_inv (const MatrixBase< D > &tangent)
 Inverse of the right Jacobian of SE(2), with tangent = [rho, theta]. More...
 
template<typename D >
void identity (MatrixBase< D > &p, typename D::Scalar &o)
 
template<typename D1 , typename D2 >
void identity (MatrixBase< D1 > &p, MatrixBase< D2 > &o)
 
template<typename D >
void identity (MatrixBase< D > &d)
 
template<typename T = double>
Matrix< T, 3, 1 > identity ()
 
void identity (VectorComposite &v)
 
VectorComposite identityComposite ()
 
template<typename D1 , typename D2 >
void inverse (const MatrixBase< D1 > &p, const typename D1::Scalar &o, MatrixBase< D2 > &ip, typename D2::Scalar &io)
 
template<typename D1 , typename D2 , typename D3 , typename D4 >
void inverse (const MatrixBase< D1 > &p, const MatrixBase< D2 > &o, MatrixBase< D3 > &ip, MatrixBase< D4 > &io)
 
template<typename D1 , typename D2 >
void inverse (const MatrixBase< D1 > &d, MatrixBase< D2 > &id)
 
template<typename D >
Matrix< typename D::Scalar, 3, 1 > inverse (const MatrixBase< D > &d)
 
void inverse (const VectorComposite &v, VectorComposite &c)
 
VectorComposite inverse (const VectorComposite &v)
 
template<typename D1 , typename D2 , typename D3 >
void compose (const MatrixBase< D1 > &p1, const typename D1::Scalar &o1, const MatrixBase< D2 > &p2, const typename D2::Scalar &o2, MatrixBase< D3 > &pc, typename D3::Scalar &oc)
 
template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void compose (const MatrixBase< D1 > &p1, const MatrixBase< D2 > &o1, const MatrixBase< D4 > &p2, const MatrixBase< D5 > &o2, MatrixBase< D7 > &pc, MatrixBase< D8 > &oc)
 
template<class D1 , class D2 , class D3 >
void compose (const MatrixBase< D1 > &_delta1, const MatrixBase< D2 > &_delta2, MatrixBase< D3 > &_delta1_compose_delta2)
 
template<class D1 , class D2 >
Matrix< typename D1::Scalar, 3, 1 > compose (const MatrixBase< D1 > &_delta1, const MatrixBase< D2 > &_delta2)
 
template<class D1 , class D2 , class D3 , class D4 , class D5 >
void compose (const MatrixBase< D1 > &_delta1, const MatrixBase< D2 > &_delta2, MatrixBase< D3 > &_delta1_compose_delta2, MatrixBase< D4 > &_J_compose_delta1, MatrixBase< D5 > &_J_compose_delta2)
 
void compose (const VectorComposite &_x1, const VectorComposite &_x2, VectorComposite &_c)
 
VectorComposite compose (const VectorComposite &x1, const VectorComposite &x2)
 
template<typename D1 , typename D2 , typename D3 >
void between (const MatrixBase< D1 > &p1, const typename D1::Scalar &o1, const MatrixBase< D2 > &p2, const typename D2::Scalar &o2, MatrixBase< D3 > &p12, typename D3::Scalar &o12)
 
template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void between (const MatrixBase< D1 > &p1, const MatrixBase< D2 > &o1, const MatrixBase< D4 > &p2, const MatrixBase< D5 > &o2, MatrixBase< D7 > &p12, MatrixBase< D8 > &o12)
 
template<typename D1 , typename D2 , typename D3 >
void between (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, MatrixBase< D3 > &d12)
 
template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > between (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2)
 
void between (const VectorComposite &x1, const VectorComposite &x2, VectorComposite &x12)
 
VectorComposite between (const VectorComposite &x1, const VectorComposite &x2)
 
template<typename D1 , typename D2 >
void exp (const MatrixBase< D1 > &rho, const typename D1::Scalar &theta, MatrixBase< D2 > &p, typename D2::Scalar &o)
 
template<typename D1 , typename D2 , typename D3 , typename D4 >
void exp (const MatrixBase< D1 > &rho, const MatrixBase< D2 > &theta, MatrixBase< D3 > &p, MatrixBase< D4 > &o)
 
template<class D1 , class D2 >
void exp (const MatrixBase< D1 > &_tau, MatrixBase< D2 > &_delta)
 
template<typename D >
Matrix< typename D::Scalar, 3, 1 > exp (const MatrixBase< D > &_tau)
 
template<class D1 , class D2 , class D3 >
void exp (const MatrixBase< D1 > &_tau, MatrixBase< D2 > &_delta, MatrixBase< D3 > &_J_delta_tau)
 
void exp (const VectorComposite &_tau, VectorComposite &_delta)
 
VectorComposite exp (const VectorComposite &tau)
 
template<typename D1 , typename D2 >
void log (const MatrixBase< D1 > &p, const typename D1::Scalar &o, MatrixBase< D2 > &rho, typename D2::Scalar &theta)
 
template<typename D1 , typename D2 , typename D3 , typename D4 >
void log (const MatrixBase< D1 > &p, const MatrixBase< D2 > &o, MatrixBase< D3 > &rho, MatrixBase< D4 > &theta)
 
template<class D1 , class D2 >
void log (const MatrixBase< D1 > &_delta, MatrixBase< D2 > &_tau)
 
template<typename D >
Matrix< typename D::Scalar, 3, 1 > log (const MatrixBase< D > &_delta)
 
template<class D1 , class D2 , class D3 >
void log (const MatrixBase< D1 > &_delta, MatrixBase< D2 > &_tau, MatrixBase< D3 > &_J_tau_delta)
 
void log (const VectorComposite &_delta, VectorComposite &_tau)
 
VectorComposite log (const VectorComposite &delta)
 
template<typename D1 , typename D2 , typename D3 >
void plus (const MatrixBase< D1 > &p1, const typename D1::Scalar &o1, const MatrixBase< D2 > &p2, const typename D2::Scalar &o2, MatrixBase< D3 > &plus_p, typename D3::Scalar &plus_o)
 
template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void plus (const MatrixBase< D1 > &p1, const MatrixBase< D2 > &o1, const MatrixBase< D4 > &p2, const MatrixBase< D5 > &o2, MatrixBase< D7 > &plus_p, MatrixBase< D8 > &plus_o)
 
template<typename D1 , typename D2 , typename D3 >
void plus (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, MatrixBase< D3 > &d_plus)
 
template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > plus (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2)
 
void plus (const VectorComposite &x, const VectorComposite &tau, VectorComposite &res)
 
VectorComposite plus (const VectorComposite &x, const VectorComposite &tau)
 
template<typename D1 , typename D2 , typename D3 >
void minus (const MatrixBase< D1 > &p1, const typename D1::Scalar &o1, const MatrixBase< D2 > &p2, const typename D2::Scalar &o2, MatrixBase< D3 > &pd, typename D3::Scalar &od)
 
template<typename D1 , typename D2 , typename D3 >
void minus (const MatrixBase< D1 > &p1, const typename D1::Scalar &o1, const MatrixBase< D2 > &p2, const typename D2::Scalar &o2, MatrixBase< D3 > &pd, typename D3::Scalar &od, typename D3::Scalar &J_do_o1, typename D3::Scalar &J_do_o2)
 
template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void minus (const MatrixBase< D1 > &p1, const MatrixBase< D2 > &o1, const MatrixBase< D4 > &p2, const MatrixBase< D5 > &o2, MatrixBase< D7 > &pd, MatrixBase< D8 > &od)
 
template<typename D1 , typename D2 , typename D3 >
void minus (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, MatrixBase< D3 > &err)
 
template<typename D1 , typename D2 , typename D3 , typename D4 , typename D5 >
void minus (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, MatrixBase< D3 > &dif, MatrixBase< D4 > &J_diff_d1, MatrixBase< D5 > &J_diff_d2)
 
template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > minus (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2)
 
void minus (const VectorComposite &x1, const VectorComposite &x2, VectorComposite &res)
 
VectorComposite minus (const VectorComposite &x1, const VectorComposite &x2)
 
template<typename D1 , typename D2 , typename D3 >
void interpolate (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, const typename D1::Scalar &t, MatrixBase< D3 > &ret)
 
template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > interpolate (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, const typename D1::Scalar &t)
 
void interpolate (const VectorComposite &x1, const VectorComposite &x2, const double &t, VectorComposite &res)
 
VectorComposite interpolate (const VectorComposite &x1, const VectorComposite &x2, const double &t)
 
template<typename D1 , typename D2 >
void toSE2 (const MatrixBase< D1 > &pose, MatrixBase< D2 > &SE2)
 
template<typename D >
Matrix< typename D::Scalar, 3, 3 > toSE2 (const MatrixBase< D > &pose)
 

Function Documentation

◆ between() [1/6]

template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > wolf::SE2::between ( const MatrixBase< D1 > &  d1,
const MatrixBase< D2 > &  d2 
)
inline

◆ between() [2/6]

template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::between ( const MatrixBase< D1 > &  d1,
const MatrixBase< D2 > &  d2,
MatrixBase< D3 > &  d12 
)
inline

◆ between() [3/6]

template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void wolf::SE2::between ( const MatrixBase< D1 > &  p1,
const MatrixBase< D2 > &  o1,
const MatrixBase< D4 > &  p2,
const MatrixBase< D5 > &  o2,
MatrixBase< D7 > &  p12,
MatrixBase< D8 > &  o12 
)
inline

◆ between() [4/6]

template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::between ( const MatrixBase< D1 > &  p1,
const typename D1::Scalar &  o1,
const MatrixBase< D2 > &  p2,
const typename D2::Scalar &  o2,
MatrixBase< D3 > &  p12,
typename D3::Scalar &  o12 
)
inline

◆ between() [5/6]

VectorComposite wolf::SE2::between ( const VectorComposite &  x1,
const VectorComposite &  x2 
)
inline

◆ between() [6/6]

void wolf::SE2::between ( const VectorComposite &  x1,
const VectorComposite &  x2,
VectorComposite &  x12 
)
inline

◆ compose() [1/7]

template<class D1 , class D2 >
Matrix< typename D1::Scalar, 3, 1 > wolf::SE2::compose ( const MatrixBase< D1 > &  _delta1,
const MatrixBase< D2 > &  _delta2 
)
inline

◆ compose() [2/7]

template<class D1 , class D2 , class D3 >
void wolf::SE2::compose ( const MatrixBase< D1 > &  _delta1,
const MatrixBase< D2 > &  _delta2,
MatrixBase< D3 > &  _delta1_compose_delta2 
)
inline

◆ compose() [3/7]

template<class D1 , class D2 , class D3 , class D4 , class D5 >
void wolf::SE2::compose ( const MatrixBase< D1 > &  _delta1,
const MatrixBase< D2 > &  _delta2,
MatrixBase< D3 > &  _delta1_compose_delta2,
MatrixBase< D4 > &  _J_compose_delta1,
MatrixBase< D5 > &  _J_compose_delta2 
)
inline

◆ compose() [4/7]

template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void wolf::SE2::compose ( const MatrixBase< D1 > &  p1,
const MatrixBase< D2 > &  o1,
const MatrixBase< D4 > &  p2,
const MatrixBase< D5 > &  o2,
MatrixBase< D7 > &  pc,
MatrixBase< D8 > &  oc 
)
inline

◆ compose() [5/7]

template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::compose ( const MatrixBase< D1 > &  p1,
const typename D1::Scalar &  o1,
const MatrixBase< D2 > &  p2,
const typename D2::Scalar &  o2,
MatrixBase< D3 > &  pc,
typename D3::Scalar &  oc 
)
inline

◆ compose() [6/7]

void wolf::SE2::compose ( const VectorComposite &  _x1,
const VectorComposite &  _x2,
VectorComposite &  _c 
)
inline

◆ compose() [7/7]

VectorComposite wolf::SE2::compose ( const VectorComposite &  x1,
const VectorComposite &  x2 
)
inline

◆ exp() [1/7]

template<typename D >
Matrix< typename D::Scalar, 3, 1 > wolf::SE2::exp ( const MatrixBase< D > &  _tau)
inline

◆ exp() [2/7]

template<class D1 , class D2 >
void wolf::SE2::exp ( const MatrixBase< D1 > &  _tau,
MatrixBase< D2 > &  _delta 
)
inline

◆ exp() [3/7]

template<class D1 , class D2 , class D3 >
void wolf::SE2::exp ( const MatrixBase< D1 > &  _tau,
MatrixBase< D2 > &  _delta,
MatrixBase< D3 > &  _J_delta_tau 
)
inline

◆ exp() [4/7]

template<typename D1 , typename D2 , typename D3 , typename D4 >
void wolf::SE2::exp ( const MatrixBase< D1 > &  rho,
const MatrixBase< D2 > &  theta,
MatrixBase< D3 > &  p,
MatrixBase< D4 > &  o 
)
inline

◆ exp() [5/7]

template<typename D1 , typename D2 >
void wolf::SE2::exp ( const MatrixBase< D1 > &  rho,
const typename D1::Scalar &  theta,
MatrixBase< D2 > &  p,
typename D2::Scalar &  o 
)
inline

◆ exp() [6/7]

void wolf::SE2::exp ( const VectorComposite &  _tau,
VectorComposite &  _delta 
)
inline

◆ exp() [7/7]

VectorComposite wolf::SE2::exp ( const VectorComposite &  tau)
inline

◆ identity() [1/5]

template<typename T = double>
Matrix< T, 3, 1 > wolf::SE2::identity ( )
inline

◆ identity() [2/5]

template<typename D >
void wolf::SE2::identity ( MatrixBase< D > &  d)
inline

◆ identity() [3/5]

template<typename D >
void wolf::SE2::identity ( MatrixBase< D > &  p,
typename D::Scalar &  o 
)
inline

◆ identity() [4/5]

template<typename D1 , typename D2 >
void wolf::SE2::identity ( MatrixBase< D1 > &  p,
MatrixBase< D2 > &  o 
)
inline

◆ identity() [5/5]

void wolf::SE2::identity ( VectorComposite &  v)
inline

◆ identityComposite()

VectorComposite wolf::SE2::identityComposite ( )
inline

◆ interpolate() [1/4]

template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > wolf::SE2::interpolate ( const MatrixBase< D1 > &  d1,
const MatrixBase< D2 > &  d2,
const typename D1::Scalar &  t 
)
inline

◆ interpolate() [2/4]

template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::interpolate ( const MatrixBase< D1 > &  d1,
const MatrixBase< D2 > &  d2,
const typename D1::Scalar &  t,
MatrixBase< D3 > &  ret 
)
inline

◆ interpolate() [3/4]

VectorComposite wolf::SE2::interpolate ( const VectorComposite &  x1,
const VectorComposite &  x2,
const double &  t 
)
inline

◆ interpolate() [4/4]

void wolf::SE2::interpolate ( const VectorComposite &  x1,
const VectorComposite &  x2,
const double &  t,
VectorComposite &  res 
)
inline

◆ inverse() [1/6]

template<typename D >
Matrix< typename D::Scalar, 3, 1 > wolf::SE2::inverse ( const MatrixBase< D > &  d)
inline

◆ inverse() [2/6]

template<typename D1 , typename D2 >
void wolf::SE2::inverse ( const MatrixBase< D1 > &  d,
MatrixBase< D2 > &  id 
)
inline

◆ inverse() [3/6]

template<typename D1 , typename D2 , typename D3 , typename D4 >
void wolf::SE2::inverse ( const MatrixBase< D1 > &  p,
const MatrixBase< D2 > &  o,
MatrixBase< D3 > &  ip,
MatrixBase< D4 > &  io 
)
inline

◆ inverse() [4/6]

template<typename D1 , typename D2 >
void wolf::SE2::inverse ( const MatrixBase< D1 > &  p,
const typename D1::Scalar &  o,
MatrixBase< D2 > &  ip,
typename D2::Scalar &  io 
)
inline

◆ inverse() [5/6]

VectorComposite wolf::SE2::inverse ( const VectorComposite &  v)
inline

◆ inverse() [6/6]

void wolf::SE2::inverse ( const VectorComposite &  v,
VectorComposite &  c 
)
inline

◆ J_Vp_theta()

template<class D , typename T >
Matrix< T, 2, 1 > wolf::SE2::J_Vp_theta ( const MatrixBase< D > &  p,
const T  theta 
)
inline

Jacobian of V(theta)*p wrt theta.

◆ jac_SE2_left()

template<typename D >
Matrix< typename D::Scalar, 3, 3 > wolf::SE2::jac_SE2_left ( const MatrixBase< D > &  tangent)
inline

Left Jacobian of SE(2), with tangent = [rho, theta]. See [1] eq. 164.

◆ jac_SE2_left_inv()

template<typename D >
Matrix< typename D::Scalar, 3, 3 > wolf::SE2::jac_SE2_left_inv ( const MatrixBase< D > &  tangent)
inline

Inverse of the left Jacobian of SE(2), with tangent = [rho, theta].

◆ jac_SE2_right()

template<typename D >
Matrix< typename D::Scalar, 3, 3 > wolf::SE2::jac_SE2_right ( const MatrixBase< D > &  tangent)
inline

Right Jacobian of SE(2), with tangent = [rho, theta]. See [1] eq. 163.

◆ jac_SE2_right_inv()

template<typename D >
Matrix< typename D::Scalar, 3, 3 > wolf::SE2::jac_SE2_right_inv ( const MatrixBase< D > &  tangent)
inline

Inverse of the right Jacobian of SE(2), with tangent = [rho, theta].

◆ log() [1/7]

template<typename D >
Matrix< typename D::Scalar, 3, 1 > wolf::SE2::log ( const MatrixBase< D > &  _delta)
inline

◆ log() [2/7]

template<class D1 , class D2 >
void wolf::SE2::log ( const MatrixBase< D1 > &  _delta,
MatrixBase< D2 > &  _tau 
)
inline

◆ log() [3/7]

template<class D1 , class D2 , class D3 >
void wolf::SE2::log ( const MatrixBase< D1 > &  _delta,
MatrixBase< D2 > &  _tau,
MatrixBase< D3 > &  _J_tau_delta 
)
inline

◆ log() [4/7]

template<typename D1 , typename D2 , typename D3 , typename D4 >
void wolf::SE2::log ( const MatrixBase< D1 > &  p,
const MatrixBase< D2 > &  o,
MatrixBase< D3 > &  rho,
MatrixBase< D4 > &  theta 
)
inline

◆ log() [5/7]

template<typename D1 , typename D2 >
void wolf::SE2::log ( const MatrixBase< D1 > &  p,
const typename D1::Scalar &  o,
MatrixBase< D2 > &  rho,
typename D2::Scalar &  theta 
)
inline

◆ log() [6/7]

void wolf::SE2::log ( const VectorComposite &  _delta,
VectorComposite &  _tau 
)
inline

◆ log() [7/7]

VectorComposite wolf::SE2::log ( const VectorComposite &  delta)
inline

◆ minus() [1/8]

template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > wolf::SE2::minus ( const MatrixBase< D1 > &  d1,
const MatrixBase< D2 > &  d2 
)
inline

◆ minus() [2/8]

template<typename D1 , typename D2 , typename D3 , typename D4 , typename D5 >
void wolf::SE2::minus ( const MatrixBase< D1 > &  d1,
const MatrixBase< D2 > &  d2,
MatrixBase< D3 > &  dif,
MatrixBase< D4 > &  J_diff_d1,
MatrixBase< D5 > &  J_diff_d2 
)
inline

◆ minus() [3/8]

template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::minus ( const MatrixBase< D1 > &  d1,
const MatrixBase< D2 > &  d2,
MatrixBase< D3 > &  err 
)
inline

◆ minus() [4/8]

template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void wolf::SE2::minus ( const MatrixBase< D1 > &  p1,
const MatrixBase< D2 > &  o1,
const MatrixBase< D4 > &  p2,
const MatrixBase< D5 > &  o2,
MatrixBase< D7 > &  pd,
MatrixBase< D8 > &  od 
)
inline

◆ minus() [5/8]

template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::minus ( const MatrixBase< D1 > &  p1,
const typename D1::Scalar &  o1,
const MatrixBase< D2 > &  p2,
const typename D2::Scalar &  o2,
MatrixBase< D3 > &  pd,
typename D3::Scalar &  od 
)
inline

◆ minus() [6/8]

template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::minus ( const MatrixBase< D1 > &  p1,
const typename D1::Scalar &  o1,
const MatrixBase< D2 > &  p2,
const typename D2::Scalar &  o2,
MatrixBase< D3 > &  pd,
typename D3::Scalar &  od,
typename D3::Scalar &  J_do_o1,
typename D3::Scalar &  J_do_o2 
)
inline

◆ minus() [7/8]

VectorComposite wolf::SE2::minus ( const VectorComposite &  x1,
const VectorComposite &  x2 
)
inline

◆ minus() [8/8]

void wolf::SE2::minus ( const VectorComposite &  x1,
const VectorComposite &  x2,
VectorComposite &  res 
)
inline

◆ plus() [1/6]

template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > wolf::SE2::plus ( const MatrixBase< D1 > &  d1,
const MatrixBase< D2 > &  d2 
)
inline

◆ plus() [2/6]

template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::plus ( const MatrixBase< D1 > &  d1,
const MatrixBase< D2 > &  d2,
MatrixBase< D3 > &  d_plus 
)
inline

◆ plus() [3/6]

template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void wolf::SE2::plus ( const MatrixBase< D1 > &  p1,
const MatrixBase< D2 > &  o1,
const MatrixBase< D4 > &  p2,
const MatrixBase< D5 > &  o2,
MatrixBase< D7 > &  plus_p,
MatrixBase< D8 > &  plus_o 
)
inline

◆ plus() [4/6]

template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::plus ( const MatrixBase< D1 > &  p1,
const typename D1::Scalar &  o1,
const MatrixBase< D2 > &  p2,
const typename D2::Scalar &  o2,
MatrixBase< D3 > &  plus_p,
typename D3::Scalar &  plus_o 
)
inline

◆ plus() [5/6]

VectorComposite wolf::SE2::plus ( const VectorComposite &  x,
const VectorComposite &  tau 
)
inline

◆ plus() [6/6]

void wolf::SE2::plus ( const VectorComposite &  x,
const VectorComposite &  tau,
VectorComposite &  res 
)
inline

◆ skew()

template<class T >
Matrix< T, 2, 2 > wolf::SE2::skew ( const T &  t)
inline

◆ skewed()

template<class D >
Matrix< typename D::Scalar, 2, 1 > wolf::SE2::skewed ( const MatrixBase< D > &  t)
inline

Compute [1]_x * t = (-t.y ; t.x)

◆ toSE2() [1/2]

template<typename D >
Matrix< typename D::Scalar, 3, 3 > wolf::SE2::toSE2 ( const MatrixBase< D > &  pose)
inline

◆ toSE2() [2/2]

template<typename D1 , typename D2 >
void wolf::SE2::toSE2 ( const MatrixBase< D1 > &  pose,
MatrixBase< D2 > &  SE2 
)
inline

◆ V_helper()

template<typename T >
Matrix< T, 2, 2 > wolf::SE2::V_helper ( const T  theta)
inline

V(theta) matrix, so that exp([rho, theta]) = [V(theta) * rho, theta]. See [1] eq. 158.

◆ V_inv_helper()

template<typename T >
Matrix< T, 2, 2 > wolf::SE2::V_inv_helper ( const T  theta)
inline

Inverse of V(theta), so that log([p, theta]) = [V(theta).inv * p, theta].